{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data block foundations, in Swifty/functional style"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Installing packages:\n",
      "\t.package(path: \"/home/ubuntu/fastai_docs/dev_swift/FastaiNotebook_07_batchnorm\")\n",
      "\t\tFastaiNotebook_07_batchnorm\n",
      "\t.package(path: \"/home/ubuntu/fastai_docs/dev_swift/SwiftCV\")\n",
      "\t\tSwiftCV\n",
      "With SwiftPM flags: []\n",
      "Working in: /tmp/tmpow6oypc5/swift-install\n",
      "Compile Swift Module 'jupyterInstalledPackages' (1 sources)\n",
      "Initializing Swift...\n",
      "Installation complete!\n"
     ]
    }
   ],
   "source": [
    "# Uncomment line below when using Colab (this installs OpenCV4)\n",
    "# %system SwiftCV/install/install_colab.sh\n",
    "%install-location $cwd/swift-install\n",
    "%install '.package(path: \"$cwd/FastaiNotebook_07_batchnorm\")' FastaiNotebook_07_batchnorm\n",
    "%install '.package(path: \"$cwd/SwiftCV\")' SwiftCV"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "//export\n",
    "import Path\n",
    "import TensorFlow\n",
    "import Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import FastaiNotebook_07_batchnorm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('inline', 'module://ipykernel.pylab.backend_inline')\n"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%include \"EnableIPythonDisplay.swift\"\n",
    "IPythonDisplay.shell.enable_matplotlib(\"inline\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## DataBlock-like manipulation in a lightweight functional, Swifty style"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The DataBlock API in Python is designed to help with the routine data manipulations involved in modelling: downloading data, loading it given an understanding of its layout on the filesystem, processing it, and feeding it into an ML framework like fastai. This is a data pipeline. How do we do this in Swift?\n",
    "\n",
    "One approach is to build a set of types (structs, protocols, etc.) which represent various stages of this pipeline. By making the types generic, we could build a library that handled data for many kinds of models. However, it is sometimes a good rule of thumb, before writing generic types, to start by writing concrete types and then to notice what to abstract into a generic later. And another good rule of thumb, before writing concrete types, is to write no types at all, and to see how far you can get with a more primitive tool for composition: functions.\n",
    "\n",
    "This notebook shows how to perform DataBlock-like operations using a _lightweight functional style_. This means, first, to rely as much as possible on _pure_ functions -- that is, functions which do nothing but return outputs based on their inputs, and which don't mutate values anywhere. Second, in particular, it means to use Swift's support for _higher-order functions_ (functions which take functions, like `map`, `filter`, `reduce`, and `compose`). Finally, this example relies on _tuples_. Like structs, tuples can have named, typed properties. Unlike structs, you don't need to name them. They can be a fast, ad-hoc way to explore the data types that you actually need, without being distracted by considering what's a method, an initializer, etc.,\n",
    "\n",
    "Swift has excellent, understated support for a such a style. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Getting Started\n",
    "\n",
    "First things first, we need to download Imagenette and untar it. What follows is very close to what we did for MNIST."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "//export\n",
    "public let dataPath = Path.home/\".fastai\"/\"data\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "//export\n",
    "public func downloadImagenette(path: Path = dataPath, sz:String=\"-320\") -> Path {\n",
    "    let url = \"https://s3.amazonaws.com/fast-ai-imageclas/imagenette\\(sz).tgz\"\n",
    "    let fname = \"imagenette\\(sz)\"\n",
    "    let file = path/fname\n",
    "    try! path.mkdir(.p)\n",
    "    if !file.exists {\n",
    "        downloadFile(url, dest:(path/\"\\(fname).tgz\").string)\n",
    "        _ = \"/bin/tar\".shell(\"-xzf\", (path/\"\\(fname).tgz\").string, \"-C\", path.string)\n",
    "    }\n",
    "    return file\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then we write a function to collect all the files in a directory, recursively."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "//export\n",
    "public func collectFiles(under path: Path, recurse: Bool = false, filtering extensions: [String]? = nil) -> [Path] {\n",
    "    var res: [Path] = []\n",
    "    for p in try! path.ls(){\n",
    "        if p.kind == .directory && recurse { \n",
    "            res += collectFiles(under: p.path, recurse: recurse, filtering: extensions)\n",
    "        } else if extensions == nil || extensions!.contains(p.path.extension.lowercased()) {\n",
    "            res.append(p.path)\n",
    "        }\n",
    "    }\n",
    "    return res\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To build our dataset, we need, at the core, only four functions that tells us:\n",
    "- how do we dowload the dataset\n",
    "- how do we get the inputs\n",
    "- how do we split them between train and valid\n",
    "- how do we label them\n",
    "\n",
    "We put those four requirements in a `DatasetConfig` protocol."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "//export\n",
    "public protocol DatasetConfig {\n",
    "    associatedtype Item\n",
    "    associatedtype Label\n",
    "    \n",
    "    static func download() -> Path\n",
    "    static func getItems(_ path: Path) -> [Item]\n",
    "    static func isTraining(_ item: Item) -> Bool\n",
    "    static func labelOf(_ item: Item) -> Label\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is what we know ahead of time about how imagenette data is laid out on disk:\n",
    "\n",
    "```\n",
    ".\n",
    "└── data                                           # <-- this is the fastai data root path\n",
    "    ├── imagenette-160                             # <-- this is the imagenette dataset path\n",
    "    │   ├── train                                  # <-- the train/ and val/ dirs are our two segments\n",
    "    │   │   ├── n01440764                          # <-- this is an image category _label_\n",
    "    │   │   │   ├── n01440764_10026.JPEG           # <-- this is an image (a _sample_) with that label\n",
    "    │   │   │   ├── n01440764_10027.JPEG\n",
    "    │   │   │   ├── n01440764_10042.JPEG\n",
    "   ...\n",
    "    │   ├── val\n",
    "    │       └── n03888257\n",
    "    │           ├── ILSVRC2012_val_00001440.JPEG\n",
    "    │           ├── ILSVRC2012_val_00002508.JPEG\n",
    "   ...  \n",
    "\n",
    "```\n",
    "\n",
    "\n",
    "We will define one type, an `enum`, to capture this information.\n",
    "\n",
    "This \"empty\" `enum` will serve only as a namespace, a grouping, for pure functions representing this information. By putting this information into one type, our code is more modular: it more clearly distinguishes facts about _this dataset_, from _general purpose data manipulators_, from _computations for this analysis_.\n",
    "\n",
    "Here's our Imagenette configuration type:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "//export\n",
    "public enum ImageNette: DatasetConfig {\n",
    "    \n",
    "    public static func download() -> Path { return downloadImagenette() }\n",
    "    \n",
    "    public static func getItems(_ path: Path) -> [Path] {\n",
    "        return collectFiles(under: path, recurse: true, filtering: [\"jpeg\", \"jpg\"])\n",
    "    }\n",
    "    \n",
    "    public static func isTraining(_ p:Path) -> Bool {\n",
    "        return p.parent.parent.basename() == \"train\"\n",
    "    }\n",
    "    \n",
    "    public static func labelOf(_ p:Path) -> String { return p.parent.basename() }\n",
    "}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From this configuration, we can get values by calling the `download`  and `getItems` function. This step would be exactly the same for all datasets following the `DatasetConfig` protocol:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "let path = ImageNette.download()\n",
    "let allFnames = ImageNette.getItems(path)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This function will use our dataset configuration to describe a given item:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "//export\n",
    "public func describeSample<C>(_ item: C.Item, config: C.Type) where C: DatasetConfig {\n",
    "    let isTraining = C.isTraining(item)\n",
    "    let label = C.labelOf(item)\n",
    "    print(\"\"\"\n",
    "          item: \\(item)\n",
    "          training?:  \\(isTraining)\n",
    "          label: \\(label)\n",
    "          \"\"\")\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "item: /home/ubuntu/.fastai/data/imagenette-320/val/n03888257/ILSVRC2012_val_00016387.JPEG\r\n",
      "training?:  false\r\n",
      "label: n03888257\r\n"
     ]
    }
   ],
   "source": [
    "describeSample(allFnames[0], config: ImageNette.self)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see that our functions for _path->isTraining_ and _path->label_ are working as expected."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Split the data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we want to split our samples into a training and validation sets. Since this is so routine we define a standard function that does so.\n",
    "\n",
    "It is enough to take an array and returns a named tuple of two arrays, one for training and one for validation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "//export\n",
    "public func partitionIntoTrainVal<T>(_ items:[T],isTrain:((T)->Bool)) -> (train:[T],valid:[T]){\n",
    "    return (train: items.filter(isTrain), valid: items.filter { !isTrain($0) })\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "var samples = partitionIntoTrainVal(allFnames, isTrain:ImageNette.isTraining)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And verify that it works as expected:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "item: /home/ubuntu/.fastai/data/imagenette-320/val/n03028079/ILSVRC2012_val_00004912.JPEG\r\n",
      "training?:  false\r\n",
      "label: n03028079\r\n"
     ]
    }
   ],
   "source": [
    "describeSample(samples.valid.randomElement()!, config: ImageNette.self)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "item: /home/ubuntu/.fastai/data/imagenette-320/train/n03417042/n03417042_17839.JPEG\r\n",
      "training?:  true\r\n",
      "label: n03417042\r\n"
     ]
    }
   ],
   "source": [
    "describeSample(samples.train.randomElement()!, config: ImageNette.self)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Process the data\n",
    "\n",
    "We process the data by taking all training labels, uniquing them, sorting them, and then defining an integer to represent the label.\n",
    "\n",
    "Those numerical labels let us define two functions, a function for label->number and the inverse function number->label.\n",
    "\n",
    "But notable point is that the process that produces those functions _is also a function_: the input is a list of training labels, and the output is the label<->number bidirectional mappings.\n",
    "\n",
    "That function which creates the bidirectional mapping is called `initState` below. Those steps are generic and might be applied for other tasks, so we define another protocol for them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "//export\n",
    "public protocol Processor {\n",
    "    associatedtype Input\n",
    "    associatedtype Output\n",
    "    \n",
    "    mutating func initState(_ items: [Input])\n",
    "    func process  (_ item: Input)  -> Output\n",
    "    func deprocess(_ item: Output) -> Input\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And the specific `CategoryProcessor` we need in this case."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "//export\n",
    "public struct CategoryProcessor: Processor {\n",
    "    private(set) public var intToLabel: [String] = []\n",
    "    private(set) public var labelToInt: [String:Int] = [:]\n",
    "    \n",
    "    public init() {}\n",
    "    \n",
    "    public mutating func initState(_ items: [String]) {\n",
    "        intToLabel = Array(Set(items)).sorted()\n",
    "        labelToInt = Dictionary(uniqueKeysWithValues:\n",
    "            intToLabel.enumerated().map{ ($0.element, $0.offset) })\n",
    "    }\n",
    "    \n",
    "    public func process(_ item: String) -> Int { return labelToInt[item]! }\n",
    "    public func deprocess(_ item: Int) -> String { return intToLabel[item] }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us create a labelNumber mapper from the training data. First we use the function `labelOf` to get all the training labels, then we can initialize a `CategoryProcessor`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "var trainLabels = samples.train.map(ImageNette.labelOf)\n",
    "var labelMapper = CategoryProcessor()\n",
    "labelMapper.initState(trainLabels)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The labelMapper now supplies the two bidirectional functions. We can verify they have the required inverse relationship:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "label = n02102040\r\n",
      "number = 1\r\n",
      "label = n02102040\r\n"
     ]
    }
   ],
   "source": [
    "var randomLabel = labelMapper.intToLabel.randomElement()!\n",
    "print(\"label = \\(randomLabel)\")\n",
    "var numericalizedLabel = labelMapper.process(randomLabel)\n",
    "print(\"number = \\(numericalizedLabel)\")\n",
    "var labelFromNumber = labelMapper.deprocess(numericalizedLabel)\n",
    "print(\"label = \\(labelFromNumber)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Label the data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we are in a position to give the data numerical labels.\n",
    "\n",
    "Now in order to map from a sample item (a `Path`), to a numerical label (an `Int`), we just compose our Path->label function with a label->int function. Curiously, Swift does not define its own compose function, so we defined a `compose` operator `>|` ourselves. We can use it to create our new function as a composition explicitly:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "// export\n",
    "public func >| <A, B, C>(_ f: @escaping (A) -> B,\n",
    "                   _ g: @escaping (B) -> C) -> (A) -> C {\n",
    "    return { g(f($0)) }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The we define a function which map a raw sample (`Path`) to a numericalized label (`Int`)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "var pathToNumericalizedLabel = ImageNette.labelOf >| labelMapper.process"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can, if we wish, compute numericalized labels over all the training and validation items:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "var trainNumLabels = samples.train.map(pathToNumericalizedLabel)\n",
    "var validNumLabels = samples.valid.map(pathToNumericalizedLabel)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We've gotten pretty far just using mostly just variables, functions, and function composition. But one downside is that our results are now scattered over a few different variables, `samples`, `trainNumLabels`, `valNumLabels`. We collect these values into one structure for convenience:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "//export\n",
    "public struct SplitLabeledData<Item,Label> {\n",
    "    public var train: [(x: Item, y: Label)]\n",
    "    public var valid: [(x: Item, y: Label)]\n",
    "    \n",
    "    public init(train: [(x: Item, y: Label)], valid: [(x: Item, y: Label)]) {\n",
    "        (self.train,self.valid) = (train,valid)\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And we can define a convenience function to build it directly from our config and a processor."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "//export\n",
    "public func makeSLD<C, P>(config: C.Type, procL: inout P) -> SplitLabeledData<C.Item, P.Output> \n",
    "where C: DatasetConfig, P: Processor, P.Input == C.Label{\n",
    "    let path = C.download()\n",
    "    let items = C.getItems(path)\n",
    "    let samples = partitionIntoTrainVal(items, isTrain:C.isTraining)\n",
    "    let trainLabels = samples.train.map(C.labelOf)\n",
    "    procL.initState(trainLabels)\n",
    "    let itemToProcessedLabel = C.labelOf >| procL.process\n",
    "    return SplitLabeledData(train: samples.train.map { ($0, itemToProcessedLabel($0)) },\n",
    "                            valid: samples.valid.map { ($0, itemToProcessedLabel($0)) })\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "var procL = CategoryProcessor()\n",
    "let sld = makeSLD(config: ImageNette.self, procL: &procL)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Opening images"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use the same compose approach to convert our images from `Path` filenames to resized images, or add all the data augmentation we want."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "//export\n",
    "import Foundation\n",
    "import SwiftCV"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First let's open those images with openCV:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "//export\n",
    "public func openImage(_ fn: Path) -> Mat {\n",
    "    return imdecode(try! Data(contentsOf: fn.url))\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And add a convenience function to have a look."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "//export\n",
    "public func showCVImage(_ img: Mat) {\n",
    "    let tensImg = Tensor<UInt8>(cvMat: img)!\n",
    "    let numpyImg = tensImg.makeNumpyArray()\n",
    "    plt.imshow(numpyImg) \n",
    "    plt.axis(\"off\")\n",
    "    plt.show()\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "showCVImage(openImage(sld.train.randomElement()!.x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The channels are in BGR instead of RGB so we first switch them with openCV"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "//export\n",
    "public func BGRToRGB(_ img: Mat) -> Mat {\n",
    "    return cvtColor(img, nil, ColorConversionCode.COLOR_BGR2RGB)\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then we can resize them"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "//export\n",
    "public func resize(_ img: Mat, size: Int) -> Mat {\n",
    "    return resize(img, nil, Size(size, size), 0, 0, InterpolationFlag.INTER_LINEAR)\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With our compose operator, the succession of transforms can be written in this pretty way:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "let transforms = openImage >| BGRToRGB >| { resize($0, size: 224) }"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And we can have a look at one of our elements:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "showCVImage(transforms(sld.train.randomElement()!.x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conversion to Tensor and batching"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we will need tensors to train our model, so we need to convert our images and ints to tensors. Images are naturally converted to tensor of bytes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "//export\n",
    "public func cvImgToTensor(_ img: Mat) -> Tensor<UInt8> {\n",
    "    return Tensor<UInt8>(cvMat: img)!\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We compose our transforms with that last function to get tensors."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "let pathToTF = transforms >| cvImgToTensor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "//export\n",
    "public func intTOTI(_ i: Int) -> TI { return TI(Int32(i)) } "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we define a `Batcher` that will be responsible for creating minibatches as an iterator. It has the properties you know from PyTorch (batch size, num workers, shuffle) and will use multiprocessing to gather the images in parallel.\n",
    "\n",
    "To be able to write `for batch in Batcher(...)`, `Batcher` needs to conform to `Sequence`, which means it needs to have a `makeIterator` function. That function has to return another struct that conforms to `IteratorProtocol`. The only thing required there is a `next` property that returns the next batch (or `nil` if we are finished).\n",
    "\n",
    "The code is pretty straightforward: we shuffle the dataset at each beginning of iteration if we want, then we apply the transforms in parallel with the use of `concurrentMap`, that works just like map but with `numWorkers` processes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "//export\n",
    "public struct Batcher<Item,Label,ScalarI: TensorFlowScalar,ScalarL: TensorFlowScalar>: Sequence {\n",
    "    public let dataset: [(Item, Label)]\n",
    "    public let xToTensor: (Item) -> Tensor<ScalarI>\n",
    "    public let yToTensor: (Label) -> Tensor<ScalarL>\n",
    "    public let collateFunc: (Tensor<ScalarI>, Tensor<ScalarL>) -> DataBatch<TF, TI>\n",
    "    public var bs: Int = 64\n",
    "    public var numWorkers: Int = 4\n",
    "    public var shuffle: Bool = false\n",
    "    \n",
    "    public init(_ ds: [(Item, Label)], \n",
    "         xToTensor: @escaping (Item) -> Tensor<ScalarI>, \n",
    "         yToTensor: @escaping (Label) ->  Tensor<ScalarL>,\n",
    "         collateFunc: @escaping (Tensor<ScalarI>, Tensor<ScalarL>) -> DataBatch<TF, TI>,\n",
    "         bs: Int = 64, numWorkers: Int = 4, shuffle: Bool = false) {\n",
    "        (dataset,self.xToTensor,self.yToTensor,self.collateFunc) = (ds,xToTensor,yToTensor,collateFunc)\n",
    "        (self.bs,self.numWorkers,self.shuffle) = (bs,numWorkers,shuffle)\n",
    "    }\n",
    "    \n",
    "    public func makeIterator() -> BatchIterator<Item,Label,ScalarI,ScalarL> { \n",
    "        return BatchIterator(self, numWorkers: numWorkers, shuffle: shuffle)\n",
    "    }\n",
    "}\n",
    "\n",
    "public struct BatchIterator<Item,Label,ScalarI: TensorFlowScalar,ScalarL: TensorFlowScalar>: IteratorProtocol {\n",
    "    public let b: Batcher<Item,Label,ScalarI,ScalarL>\n",
    "    public var numWorkers: Int = 4\n",
    "    private var idx: Int = 0\n",
    "    private var ds: [(Item, Label)]\n",
    "    \n",
    "    public init(_ batcher: Batcher<Item,Label,ScalarI,ScalarL>, numWorkers: Int = 4, shuffle: Bool = false){ \n",
    "        (b,self.numWorkers,idx) = (batcher,numWorkers,0) \n",
    "        self.ds = shuffle ? b.dataset.shuffled() : b.dataset\n",
    "    }\n",
    "    \n",
    "    public mutating func next() -> DataBatch<TF,TI>? {\n",
    "        guard idx < b.dataset.count else { return nil }\n",
    "        let end = idx + b.bs < b.dataset.count ? idx + b.bs : b.dataset.count \n",
    "        let samples = Array(ds[idx..<end])\n",
    "        idx += b.bs\n",
    "        return b.collateFunc(Tensor<ScalarI>(concatenating: samples.concurrentMap(nthreads: numWorkers) { \n",
    "            self.b.xToTensor($0.0).expandingShape(at: 0) }), \n",
    "                Tensor<ScalarL>(concatenating: samples.concurrentMap(nthreads: numWorkers) { \n",
    "            self.b.yToTensor($0.1).expandingShape(at: 0) }))\n",
    "    }\n",
    "    \n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "SetNumThreads(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "//export\n",
    "public func collateFunc(_ xb: Tensor<UInt8>, _ yb: TI) -> DataBatch<TF, TI> {\n",
    "    return DataBatch(xb: TF(xb)/255.0, yb: yb)\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "let batcher = Batcher(sld.train, xToTensor: pathToTF, yToTensor: intTOTI, collateFunc: collateFunc, bs:256, shuffle:true)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "average: 13428.859224 ms,   min: 13428.859224 ms,   max: 13428.859224 ms\r\n"
     ]
    }
   ],
   "source": [
    "time {var c = 0\n",
    "      for batch in batcher { c += 1 }\n",
    "     }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "let firstBatch = batcher.first(where: {_ in true})!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "//export\n",
    "func showTensorImage(_ img: TF) {\n",
    "    let numpyImg = img.makeNumpyArray()\n",
    "    plt.imshow(numpyImg) \n",
    "    plt.axis(\"off\")\n",
    "    plt.show()\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "showTensorImage(firstBatch.xb[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "success\r\n"
     ]
    }
   ],
   "source": [
    "import NotebookExport\n",
    "let exporter = NotebookExport(Path.cwd/\"08c_data_block_generic.ipynb\")\n",
    "print(exporter.export(usingPrefix: \"FastaiNotebook_\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Swift",
   "language": "swift",
   "name": "swift"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
